home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / DIAGXPRT.PAK / SETUP.H < prev    next >
C/C++ Source or Header  |  1997-05-06  |  11KB  |  450 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows
  3. // (C) Copyright 1993, 1995 by Borland International, All Rights Reserved
  4. //
  5. //----------------------------------------------------------------------------
  6. #if !defined(SETUP_H)
  7. #define SETUP_H
  8.  
  9. #include <owl/scrollba.h>
  10. #include <owl/button.h>
  11. #include <owl/listbox.h>
  12. #include <owl/checkbox.h>
  13. #include <owl/radiobut.h>
  14. #include <owl/edit.h>
  15. #include <owl/static.h>
  16. #include <classlib/arrays.h>
  17. #include <stdio.h>
  18. #include "diagxprt.rh"
  19.  
  20. class TDiagEnable;
  21. class TSizableDialog;
  22. class TSetupDialog;
  23.  
  24. class TSetupItem;
  25. class TSysItem;
  26. class TUsrItem;
  27.  
  28. class TBaseSetupWindow;
  29. class TSysWindow;
  30. class TUsrWindow;
  31.  
  32. class TGroup;
  33. class TSysGroup;
  34. class TUsrGroup;
  35. class TGroupScroll;
  36.  
  37. #define SYS_INI "owl.ini"
  38. #define SYS_CLS "Diagnostics"
  39. #define SYS_DSC "Diagnostics Descriptions"
  40. #define USR_INI "owl.ini"
  41. #define USR_CLS "Diagnostics"
  42. #define USR_DSC "Users Diagnostics Descriptions"
  43.  
  44. //
  45. //
  46. //
  47. class TDiagEnable : public TCheckBox {
  48.   public:
  49.     TDiagEnable(TWindow* parent, int id, TWindow* w0, TWindow* w1)
  50.       : W0(w0), W1(w1), S0(0), S1(0), TCheckBox(parent, id) {}
  51.     TDiagEnable(TWindow* parent, int id, TGroup* s0, TGroup* s1)
  52.       : W0(0), W1(0), S0(s0), S1(s1), TCheckBox(parent, id) {}
  53.     void  BNClicked();
  54.     bool  EnableWindow(bool enable);
  55.  
  56.   protected:
  57.     TGroup*  S0;
  58.     TGroup*  S1;
  59.     TWindow* W0;
  60.     TWindow* W1;
  61.  
  62.   DECLARE_RESPONSE_TABLE(TDiagEnable);
  63. };
  64.  
  65. //
  66. //
  67. //
  68. class TUsrEnable : public TDiagEnable {
  69.   public:
  70.     TUsrEnable(TWindow *w, int nID, TWindow *w0, TWindow *w1, TWindow *B) :
  71.       Ntf(B), TDiagEnable(w, nID, w0, w1) {}
  72.  
  73.     void  EvSetFocus(HWND h) {
  74.       if (Ntf && !Ntf->IsWindowEnabled()) Ntf->EnableWindow(true);
  75.       TDiagEnable::EvSetFocus(h);
  76.     }
  77.     void  EvKillFocus(HWND h) {
  78.       if (Ntf && Ntf->IsWindowEnabled()) Ntf->EnableWindow(false);
  79.       TDiagEnable::EvKillFocus(h);
  80.     }
  81.  
  82.   private:
  83.     TWindow* Ntf;
  84.  
  85.     DECLARE_RESPONSE_TABLE(TUsrEnable);
  86. };
  87.  
  88. //
  89. //
  90. //
  91. class TMainEnable : public TDiagEnable {
  92.   public:
  93.     TMainEnable(TWindow* parent, int id, TGroup* g0, TGroup* g1);
  94.     void Load();
  95.     void Save();
  96.  
  97.   private:
  98.     static char* Class;
  99. };
  100.  
  101. //
  102. //
  103. //
  104. class TSetupItem {
  105.   public:
  106.     TSetupItem(char *Class, char *Descr);
  107.     virtual ~TSetupItem() { delete EnableCheck; }
  108.  
  109.     virtual char*  GetIniFile() = 0;
  110.     virtual char*  GetSection() = 0;
  111.     virtual char*  GetSectionDesc() = 0;
  112.     const char*    GetDescr() { return Descr.c_str(); }
  113.     const char*    GetClass() { return Class.c_str(); }
  114.     void           SetClass(char* c) { Class = c; }
  115.     void           SetDescr(char* d) { Descr = d; }
  116.     virtual void operator =(TBaseSetupWindow& w);
  117.     virtual void   Load();
  118.     virtual void   Save();
  119.     bool           GetEnable() {return bEnable;}
  120.     int            GetLevel()  {return level;}
  121.     void           SetEnable(bool s) {bEnable = s; }
  122.     void           SetLevel(int n) { level = n; }
  123.  
  124.   protected:
  125.     TDiagEnable*   EnableCheck;
  126.     string         Class;
  127.     string         Descr;
  128.  
  129.   private:
  130.     bool    bEnable;
  131.     int     level;
  132. };
  133.  
  134. //
  135. //
  136. //
  137. class TSysItem : public TSetupItem {
  138.   public:
  139.     TSysItem(char* clss, char* descr = 0) : TSetupItem(clss, descr) {}
  140.     virtual char*  GetIniFile() { return SYS_INI; }
  141.     virtual char*  GetSection() { return SYS_CLS; }
  142.     virtual char*  GetSectionDesc() { return SYS_DSC; }
  143. };
  144.  
  145. //
  146. //
  147. //
  148. class TUsrItem : public TSetupItem {
  149.   public:
  150.     TUsrItem(char* clss, char* descr = 0) : TSetupItem(clss, descr) {}
  151.     virtual char*  GetIniFile() { return USR_INI; }
  152.     virtual char*  GetSection() { return USR_CLS; }
  153.     virtual char*  GetSectionDesc() { return USR_DSC; }
  154. };
  155.  
  156. //
  157. //
  158. //
  159. class TBaseSetupWindow {
  160.   public:
  161.     TBaseSetupWindow() : EnableCheck(0) {}
  162.     virtual bool  GetEnable() { CHECK(EnableCheck!=0); return EnableCheck->GetCheck(); }
  163.     virtual void  SetEnable(bool e) { CHECK(EnableCheck!=0); EnableCheck->SetCheck(e); }
  164.     virtual void  EnableWindow(bool e) = 0;
  165.     virtual int   GetLevel() = 0;
  166.     virtual void  SetLevel(int level) = 0;
  167.     virtual void  operator =(TSetupItem& it) = 0;
  168.     virtual void  operator =(int) = 0;
  169.   protected:
  170.     TDiagEnable* EnableCheck;
  171. };
  172.  
  173. //
  174. //
  175. //
  176. template <class C1,class C2>
  177. class TSetupWindow : public TBaseSetupWindow {
  178.   public:
  179.     virtual int   GetLevel() = 0;
  180.     virtual void  SetLevel(int level) = 0;
  181.  
  182.     virtual void  EnableWindow(bool e) {
  183.               EnableCheck->EnableWindow(e);
  184.               if (e)
  185.                 e = EnableCheck->GetCheck();
  186.               Child1->EnableWindow(e);
  187.               Child2->EnableWindow(e);
  188.             }
  189.     virtual void operator =(TSetupItem& it) {
  190.               SetEnable(it.GetEnable());
  191.               SetLevel(it.GetLevel());
  192.               EnableCheck->SetWindowText(it.GetDescr());
  193.               EnableCheck->ShowWindow(SW_SHOW);
  194.               Child1->ShowWindow(SW_SHOW);
  195.               Child2->ShowWindow(SW_SHOW);
  196.             }
  197.     virtual void  operator = (int) {
  198.               EnableCheck->ShowWindow(SW_HIDE);
  199.               Child1->ShowWindow(SW_HIDE);
  200.               Child2->ShowWindow(SW_HIDE);
  201.             }
  202.  
  203.   protected:
  204.     C1* Child1;
  205.     C2* Child2;
  206. };
  207.  
  208. //
  209. //
  210. //
  211. class TSysWindow : public TSetupWindow<TRadioButton,TRadioButton> {
  212.   public:
  213.     TSysWindow(TWindow* w, int i) {
  214.               Child1 = new TRadioButton(w, i + 1, 0);
  215.               Child1->Create();
  216.               Child2 = new TRadioButton(w, i + 2, 0);
  217.               Child2->Create();
  218.               EnableCheck = new TDiagEnable(w, i, Child1, Child2);
  219.               EnableCheck->Create();
  220.             }
  221.     virtual int   GetLevel() { return Child1->GetCheck() ? 1 : 0; }
  222.     virtual void  SetLevel(int level) {
  223.               if (level)
  224.                 Child1->SetCheck(1);
  225.               else
  226.                 Child2->SetCheck(1);
  227.             }
  228. };
  229.  
  230. //
  231. //
  232. //
  233. class TUsrWindow : public TSetupWindow<TStatic, TEdit> {
  234.   public:
  235.     TUsrWindow(TWindow* w, int i) {
  236.       Child1 = new TStatic(w, i + 1, 20);
  237.       Child1->Create();
  238.       Child2 = new TEdit(w, i + 2);
  239.       Child2->Create();
  240.       EnableCheck = new TDiagEnable(w, i, Child1, Child2);
  241.       EnableCheck->Create();
  242.     }
  243.     virtual int GetLevel() {
  244.       char b[6];
  245.       Child2->GetWindowText(b, sizeof(b));
  246.       return atoi(b);
  247.     }
  248.     virtual void  SetLevel(int level) {
  249.       char b[6];
  250.       sprintf(b, "%d", level);
  251.       Child2->SetWindowText(b);
  252.     }
  253. };
  254.  
  255. //
  256. //
  257. //
  258. class TItemsArray : public TArrayAsVector<TSetupItem *> {
  259.   public:
  260.     TItemsArray() : TArrayAsVector<TSetupItem*>(10, 0, 4) {}
  261. };
  262.  
  263. //
  264. //
  265. //
  266. class TWindowArray : public TArrayAsVector<TBaseSetupWindow*> {
  267.   public:
  268.     TWindowArray() : TArrayAsVector<TBaseSetupWindow*>(10, 0, 4) {}
  269. };
  270.  
  271. //
  272. //
  273. //
  274. class TGroup {
  275.   public:
  276.     enum { MapToTop = 0, MapToBottom = 0x7fff, MapAsBefore = 0x7ffe };
  277.  
  278.     TWindowArray Windows;
  279.     TItemsArray Items;
  280.  
  281.     virtual void  SetMainSwitch(TCheckBox* c) { Switch = c; }
  282.     virtual bool  IsEnable() { return Switch ? Switch->GetCheck() : 1; }
  283.     virtual void  EnableWindow(bool enable);
  284.     virtual void  Load();
  285.     virtual void  Save();
  286.     virtual void  Cleanup() = 0;
  287.     virtual int   Map(int x);
  288.     virtual int   UnMap();
  289.     virtual ~TGroup();
  290.  
  291.   private:
  292.     int        scrollPos;
  293.     TCheckBox* Switch;
  294. };
  295.  
  296. //
  297. //
  298. //
  299. class TSysGroup : public TGroup {
  300.   public:
  301.     TSysGroup(TWindow* dialog, int firstID);
  302.     void  Cleanup();
  303. };
  304.  
  305. //
  306. //
  307. //
  308. class TUsrGroup : public TGroup {
  309.   public:
  310.     TUsrGroup(TWindow* dialog, int firstID);
  311.     void  Cleanup();
  312. };
  313.  
  314. //
  315. //
  316. //
  317. class TSizableDialog : public TDialog {
  318.   public:
  319.     TSizableDialog(TWindow* parent, int dlgID, int boxID) : nBoxID(boxID),
  320.                    TDialog(parent, dlgID) {}
  321.     enum { t_minmax, t_min, t_max };
  322.  
  323.     virtual void  Toggle(int type = t_minmax);
  324.     bool    IsMaximized() { return bMaximized; }
  325.  
  326.   protected:
  327.     virtual void  SetupWindow();
  328.     virtual void  EnableControls();
  329.     void  Center();
  330.     void  AdjustPos();
  331.  
  332.   private:
  333.     int   nBoxID;
  334.     TSize small;
  335.     TSize large;
  336.     bool  bMaximized;
  337.     int   tSize;
  338. };
  339.  
  340. //
  341. //
  342. //
  343. class TSetupDialog : public TSizableDialog {
  344.   public:
  345.     TSetupDialog(TWindow* p):TSizableDialog(p, IDD_OPTIONS, ID_BOX) {}
  346.     void  SetupWindow();
  347.     void  CleanupWindow();
  348.     void  UpdateButtons();
  349.     void  CmOk();
  350.     void  CmAddUsr();
  351.     void  CmDelUsr();
  352.     void  CmEdtUsr();
  353.     void  CmZoom();
  354.  
  355.   private:
  356.     TSysGroup*    SysGroup;
  357.     TUsrGroup*    UsrGroup;
  358.     TMainEnable*  MainEnable;
  359.     TGroupScroll* SysScroll;
  360.     TGroupScroll* UsrScroll;
  361.     TButton*      pDel;
  362.     TButton*      pEdt;
  363.  
  364.   DECLARE_RESPONSE_TABLE(TSetupDialog);
  365. };
  366.  
  367. //
  368. //
  369. //
  370. class TGroupScroll : public TScrollBar {
  371.   public:
  372.     TGroupScroll(TWindow *W, int id, TGroup *group);
  373.     void  Initialize(int pos);
  374.     void  EvVScroll(uint code, uint pos, HWND hCtl);
  375.     void  SetPosition(int pos);
  376.     void  EndScroll();
  377.  
  378.   private:
  379.     int     x;
  380.     int     min;
  381.     int     max;
  382.     TGroup* group;
  383.  
  384.   DECLARE_RESPONSE_TABLE(TGroupScroll);
  385. };
  386.  
  387. //
  388. //  class TAddUsrDialog
  389. //
  390. class TAddUsrDialog : public TDialog {
  391.   public:
  392.     char Class[80], Descr[80];
  393.     TAddUsrDialog(TWindow* p): TDialog(p, IDD_ADD_CUSTOM) {}
  394.     void CmOk();
  395.  
  396.   DECLARE_RESPONSE_TABLE(TAddUsrDialog);
  397. };
  398.  
  399. //
  400. //  class TItemsDialog
  401. //
  402. class TItemsDialog : public TDialog {
  403.   public:
  404.     TItemsDialog(TWindow* p, int id, TItemsArray* it): items(it), TDialog(p, id) {}
  405.     ~TItemsDialog();
  406.  
  407.     virtual bool  IsValid() { return true; }
  408.     virtual void  SetupWindow();
  409.     virtual void  CmOk() { if (IsValid()) TDialog::CmOk(); }
  410.     virtual void  LBDblClk() {}
  411.     virtual void  LBSelChange() {}
  412.  
  413.     TItemsArray* items;
  414.     int          nSel;
  415.  
  416.   protected:
  417.     TListBox*  pList;
  418.  
  419.   DECLARE_RESPONSE_TABLE(TItemsDialog);
  420. };
  421.  
  422. //
  423. //  class TDelUsrDialog
  424. //
  425. class TDelUsrDialog : public TItemsDialog {
  426.   public:
  427.     TDelUsrDialog(TWindow* p, TItemsArray* it): TItemsDialog(p, IDD_DEL_CUSTOM, it) {}
  428.     virtual void  CmOk();
  429.     virtual void  LBDblClk() { CmOk(); }
  430. };
  431.  
  432. //
  433. //  class TEdtUsrDialog
  434. //
  435. class TEdtUsrDialog : public TItemsDialog {
  436.   public:
  437.     TEdtUsrDialog(TWindow* p, TItemsArray* it)
  438.         : nPrevSel(LB_ERR), TItemsDialog(p, IDD_EDT_CUSTOM, it) {}
  439.     virtual void  LBSelChange();
  440.     virtual void  CmOk();
  441.  
  442.   private:
  443.     int   nPrevSel;
  444.     static  char*  Template;
  445.  
  446.   DECLARE_RESPONSE_TABLE(TEdtUsrDialog);
  447. };
  448.  
  449. #endif
  450.